Many hardware/software applications rely on a database for the storage of data records. A database may generally be understood as a collection of records stored upon a hardware device in a systematic way.
As the need to store increased amounts of data grows, so does the need to efficiently store and access the data. Databases are used to store large volumes of data, and therefore the applications that are used to write to them, and read from them, need to be implemented to make the most efficient use of the databases.
Regardless of the volume of data stored upon a database, when using multiple databases for the purposes of data storage, two elements will typically be in common, the first being a means by which data records may be stored, and the second a locking mechanism. The locking mechanism controls access to the data records stored on the database.
Where large volumes of data are being stored on a database, or a large number of requests are made for the data, a bottleneck often develops where the database is not able to serve the read and write requests fast enough. Examples of such bottlenecks are found in many applications and environments. Bottlenecks may occur for a variety of reasons, including, but not limited to, where the database is experiencing too heavy a load (too many requests are being made to the database), the task the database is being asked to perform is performed inefficiently (therefore slowing down response times), or where the database does not possess the required processing ability to respond to the request in an efficient manner.
One solution proposed to deal with database bottlenecks is to store the database upon a server with increased processing ability. There are several drawbacks to such an approach. One such drawback involves the cost of the server and associated software, as the cost often increases exponentially with the processing capability of the server. Another drawback relates to when provisions are being made for availability or disaster recovery, where an additional significant cost is encountered in acquiring and maintaining a second server of equivalent size and cost that is idle and does not contribute to the data processing ability (otherwise there is still a single point of failure in the system).
Another proposed solution to address the database bottleneck problem, is to utilize a cluster of smaller database servers which process the data records and which utilize a single, common device for the storage of the database records (i.e. only a single copy of the database records exists). This solution does provide a lower cost incremental capability for increasing the processing ability of the database (augmented by adding new servers) but still can encounter a bottleneck for the shared storage resource.
Yet another proposed solution is to use a cluster of database servers, where each server has its own private and identical set of database records (a plurality of database servers) along with a separate, centralized device that virtualizes (to external clients) the cluster of database servers into a single database instance. This external device is then responsible for ensuring that all database requests and transactions are delivered to each of the database servers in the cluster in a way that ensures the accuracy and consistency of the database records. There are several algorithms used for performing this distribution. Some algorithms used to implement this solution require the completion of all operations associated with a particular transaction before the next transaction is executed, even when it is not necessary to wait for the completion of the preceding transaction. Such algorithms therefore tend to not make efficient use of the multiple database resources that are available for use.
The performance issues associated with the use of distributed database clusters tend to be associated with the database records, and the size of the database records that are accessed.
When dealing with database records in a distributed database environment, in order to ensure accuracy across the various databases, database locks are issued in order to ensure that there is consistency of data. Therefore, read and write locks are issued when a read or write function may not be performed because a previous operation is still pending. The locks that are issued such that they lock the entire database record, may not be required where the operation that is to be performed may only modify a certain element within the record.